// 云对象教程: https://uniapp.dcloud.net.cn/uniCloud/cloud-obj
// jsdoc语法提示教程：https://ask.dcloud.net.cn/docs/#//ask.dcloud.net.cn/article/129

// const db = uniCloud.database();
let db = uniCloud.databaseForJQL()

function noErrorResult(result) {
	result["errCode"] = 0
	result["errMsg"] = ""
	return result
}
module.exports = {
	_before: function() { // 通用预处理器
		db = uniCloud.databaseForJQL({ clientInfo: this.getClientInfo() })
		const dbCmd = db.command
	},

	//-------------------------品牌数据相关请求-------------------------

	/**
	 * 此方法已弃用
	 * getBrandList:返回品牌列表数量
	 * @returns {object} 返回值
	 */
	async getBrandCount() {
		try {
			// const dbJQL = uniCloud.databaseForJQL({
			// 	clientInfo: this.getClientInfo()
			// })
			let res = await db.collection('kdb-brand').count()
			res.limit = 20
			// 返回时设置单次返回的记录条数，从这里设置前端就可以不用单独修改了
			return res
		} catch (e) {
			return e
		}
	},
	/**
	 * getBrandList:返回可用品牌列表
	 * @returns {object} 返回值
	 */
	async getBrands() {
		try {
			let res = await db.collection('kdb-brand').where('is_enable == true').field("brand").orderBy(
				'create_time desc').get()
			return res
		} catch (e) {
			return e
		}
	},

	/**
	 * getBrandList:返回品牌列表
	 * @returns {object} 返回值
	 */
	async getBrandList(param) {
		if (param === null) {
			return {
				errCode: 'PARAM_IS_NULL',
				errMsg: '参数不能为空'
			}
		}
		try {
			// const dbJQL = uniCloud.databaseForJQL({
			// 	clientInfo: this.getClientInfo()
			// })
			// console.log(param.skip)
			let res = await db.collection('kdb-brand').orderBy('is_enable desc,create_time desc').skip(param)
				.limit(20).get({
					getCount: true
				})
			return res
		} catch (e) {
			return e
		}
	},
	/**
	 * addBrand:新增一个品牌
	 * @param {object} 一条记录
	 * @returns {object} 返回值
	 */
	async addBrand(record) {
		try {
			// const dbJQL = uniCloud.databaseForJQL({
			// 	clientInfo: this.getClientInfo()
			// })
			let res = await db.collection('kdb-brand').add(record)
			return res
		} catch (e) {
			return e
		}
	},
	/**
	 * updateBrand:更新一个品牌
	 * @param {object} 一条记录
	 * @returns {object} 返回值
	 */
	async updateBrand(id, record) {
		if (record._id === null) {
			return {
				errCode: 'ID_IS_NULL',
				errMsg: '记录ID不能为空'
			}
		}
		try {
			let res = await db.collection('kdb-brand').doc(id).update(record)
			return res
		} catch (e) {
			return e
		}
	},
	/**
	 * deleteBrand:删除一个品牌
	 * @param {string} id 记录id
	 * @returns {object} 返回值
	 */
	async deleteBrand(id) {
		try {
			let res = await db.collection('kdb-brand').doc(id).remove()
			return res
		} catch (e) {
			return e
		}
	},
	//-------------------------————————————————————------------------

	//-------------------------故障案例相关请求-------------------------	
	/**
	 * getAllFaultSampleList:返回故障案例列表
	 * @returns {object} 返回值
	 */
	async getAllFaultSampleList(param) {
		try {
			if (param === null) {
				return {
					errCode: 'PARAM_IS_NULL',
					errMsg: '参数不能为空'
				}
			}

			if (!param.pageNo || !param.pageSize) {
				return {
					errCode: 'PAGE_PARAM_IS_NULL',
					errMsg: '分页参数不能为空'
				}
			}
			let pageNo = parseInt(param.pageNo);
			let pageSize = parseInt(param.pageSize);
			let type = param.type || 0; //这是分类标签

			if (pageNo < 0 || pageSize <= 0) {
				return {
					errCode: 'PAGE_DATA_IS_ZERO',
					errMsg: '分页数据不能为零'
				}
			}

			if (pageNo == 0) {
				pageNo = 1;
			}

			if (type === 1) {
				// 所有案列不包含已删除 或者 私有案例
				const sample = db.collection('kfault-sample-set')
					.where(db.command.nor([ //都不满足以下条件才筛选出来
						{ is_delete: db.command.eq(true) }, //等于删除
						{ private: db.command.eq(true) }, //等于私有
					]))
					.getTemp()
				const user = db.collection('uni-id-users')
					.where({ _id: db.command.eq(db.getCloudEnv('$cloudEnv_uid')) })
					.field('_id,nickname')
					.getTemp()

				let res = await db.collection(sample, user)
					.orderBy('create_time desc')
					.skip(param.pageSize * (pageNo - 1))
					.limit(param.pageSize)
					.get({ getCount: true })

				return res
			} else if (type === 2) {

				// 我的案列指定创建者ID等于登录ID，排除已删除案列.双条件必须同时满足 or 条件
				const sample = db.collection('kfault-sample-set')
					.where({
						user_id: db.command.eq(db.getCloudEnv('$cloudEnv_uid')),
						is_delete: db.command.neq(true)
					}).getTemp()

				const user = db.collection('uni-id-users')
					.where({ _id: db.command.eq(db.getCloudEnv('$cloudEnv_uid')) })
					.field('_id,nickname')
					.getTemp()

				let res = await db.collection(sample, user)
					.where({ is_delete: db.command.neq(true) })
					.orderBy('create_time desc').skip(param.pageSize * (pageNo - 1))
					.limit(param.pageSize)
					.get({ getCount: true })

				return res
			} else if (type === 3) {
				// 先查出当前账户收藏记录 我的案列是当前登录账户
				const favsample = db.collection('ksample-favorite')
					.where({ user_id: db.getCloudEnv('$cloudEnv_uid') })
					.getTemp()
				// 再查出账户的昵称字段，过滤掉其他用户
				const user = db.collection('uni-id-users')
					.where({ _id: db.getCloudEnv('$cloudEnv_uid') })
					.field('_id,nickname')
					.getTemp()
				// 再查找过滤案列表 我的收藏案列必须是没有删除的
				const sample = db.collection('kfault-sample-set')
					.where({ is_delete: db.command.neq(true) })
					.getTemp()

				let res = await db.collection(favsample, user, sample).orderBy(
						'create_time desc').skip(param.pageSize * (pageNo - 1))
					.limit(param.pageSize).get({
						getCount: true
					})
				// 将查询的数据整理成统一的返回格式
				let returnres = []
				for (let i = 0; i < res.data.length; i++) {
					returnres.push(res.data[i].sample_id[0])
					returnres[i].user_id = res.data[i].user_id
				}
				res.data = returnres
				return res
			} else {
				return {
					errCode: 'SAMPLE_DATA_FIND_ERR',
					errMsg: '案列数据查询出错'
				}
			}

		} catch (e) {
			return e
		}
	},

	/** 
	 * addFaultSample:新增故障案例
	 * @returns {object} 返回值
	 */
	async addFaultSample(param) {
		try {
			if (param === null) {
				return {
					errCode: 'PARAM_IS_NULL',
					errMsg: '参数不能为空'
				}
			}
			let res = await db.collection('kfault-sample-set').add(param)
			return res
		} catch (e) {
			return e
		}
	},

	/** 
	 * updataFaultSample:编辑故障案例
	 * @returns {object} 返回值
	 */
	async updataFaultSample(id, param) {
		try {
			if (param === null) {
				return {
					errCode: 'PARAM_IS_NULL',
					errMsg: '参数不能为空'
				}
			}
			if (id === null) {
				return {
					errCode: 'ID_IS_NULL',
					errMsg: '记录ID不能为空'
				}
			}
			let res = await db.collection('kfault-sample-set').doc(id).update(param)
			return res
		} catch (e) {
			return e
		}
	},
	//-------------------------————————————————————------------------

	//------------------------案列和文章收藏相关请求---------------------	

	/**
	 * getFavAndLikeStatus:返回案列或文章的收藏状态
	 * @returns {int} 返回值 0 或 1
	 */
	async getFavAndLikeStatus(param) {
		try {
			if (param === null) {
				return {
					errCode: 'PARAM_IS_NULL',
					errMsg: '参数不能为空'
				}
			}
			let data = {
				fav: false,
				like: false
			}

			let Favres = await db.collection('ksample-favorite').where({
				user_id: db.getCloudEnv('$cloudEnv_uid'),
				sample_id: param
			}).get({
				getCount: true
			})
			let Likeres = await db.collection('ksample-like').where({
				user_id: db.getCloudEnv('$cloudEnv_uid'),
				sample_id: param
			}).get({
				getCount: true
			})

			if (Favres.count > 0) {
				data.fav = true
			} else {
				data.fav = false
			}

			if (Likeres.count > 0) {
				data.like = true
			} else {
				data.like = false
			}

			return data
		} catch (e) {
			return e
		}
	},

	/**
	 * getFavoriteStatus:返回案列或文章的收藏状态
	 * @returns {int} 返回值 0 或 1
	 */
	async getFavoriteStatus(param) {
		try {
			if (param === null) {
				return {
					errCode: 'PARAM_IS_NULL',
					errMsg: '参数不能为空'
				}
			}
			let res = await db.collection('ksample-favorite').where({
				user_id: db.getCloudEnv('$cloudEnv_uid'),
				sample_id: param
			}).get({
				getCount: true
			})
			if (res.count > 0) {
				return true
			} else {
				return false
			}
		} catch (e) {
			return e
		}
	},

	/**
	 * setFavoriteStatus:返回案列或文章的收藏状态
	 * @returns {int} 返回值 true 或 false
	 */
	async setFavoriteStatus(param) {
		try {
			if (param === null) {
				return {
					errCode: 'PARAM_IS_NULL',
					errMsg: '参数不能为空'
				}
			}
			let res = await db.collection('ksample-favorite').where({
				user_id: db.getCloudEnv('$cloudEnv_uid'),
				sample_id: param
			}).get({
				getCount: true
			})

			if (res.count === 0) {
				// 没有收藏记录，新增一个记录
				let favoriteRecord = {
					sample_id: param
				}
				let addres = await db.collection('ksample-favorite').add(favoriteRecord)
				if (addres.errCode === 0) {
					return true
				} else {
					return {
						errCode: 'FAVORITE_IS_FAIL',
						errMsg: '收藏失败'
					}
				}
			} else if (res.count === 1) {
				// 有收藏记录，删除收藏记录
				let deleteres = await db.collection('ksample-favorite').where({
					user_id: db.getCloudEnv('$cloudEnv_uid'),
					sample_id: param
				}).remove()
				if (deleteres.errCode === 0) {
					return false
				} else {
					return {
						errCode: 'CANCEL_FAVORITE_IS_FAIL',
						errMsg: '取消收藏失败'
					}
				}
			}

		} catch (e) {
			return e
		}
	},

	/**
	 * getlikeStatus:返回案列或文章的点赞状态
	 * @returns {int} 返回值 0 或 1
	 */
	async getlikeStatus(param) {

		try {
			if (param === null) {
				return {
					errCode: 'PARAM_IS_NULL',
					errMsg: '参数不能为空'
				}
			}
			let res = await db.collection('ksample-like').where({
				user_id: db.getCloudEnv('$cloudEnv_uid'),
				sample_id: param
			}).get({
				getCount: true
			})
			if (res.count > 0) {
				return true
			} else {
				return false
			}
		} catch (e) {
			return e
		}
	},


	/**
	 * setLikeStatus:设置案列或文章的点赞状态
	 * @returns {int} 返回值 true 或 false
	 */
	async setLikeStatus(param) {

		try {
			if (param === null) {
				return {
					errCode: 'PARAM_IS_NULL',
					errMsg: '参数不能为空'
				}
			}

			//查找该案列是否被点赞
			const res = await db.collection('ksample-like').where({
				user_id: db.getCloudEnv('$cloudEnv_uid'),
				sample_id: param
			}).get({
				getCount: true
			})

			if (res.count === 0) {
				// 没有被点赞，新增一个记录
				const likeRecord = {
					sample_id: param
				}
				const addres = await db.collection('ksample-like').add(likeRecord)
				if (addres.errCode === 0) {
					//这里汇总该案列的点赞数量
					//汇总此案例点赞数量
					const likecount = await db.collection('ksample-like').where({
						sample_id: param
					}).get({
						getCount: true
					})
					//切换用户权限，不然数据写不了
					db.setUser({
						role: ['admin']
					})
					//写入点赞的合计数量
					const updatastatue = await db.collection('kfault-sample-set').doc(param)
						.update({ likes: likecount.count })

					// 返回点赞成功，因为记录已经写入点赞表了。合计和汇总的返回数据无需验证。这个表不是很重要。
					return true
				} else {
					return {
						errCode: 'LIKE_IS_FAIL',
						errMsg: '点赞失败'
					}
				}
			} else if (res.count === 1) {
				// 有收藏记录，删除收藏记录
				let deleteres = await db.collection('ksample-like').where({
					user_id: db.getCloudEnv('$cloudEnv_uid'),
					sample_id: param
				}).remove()
				if (deleteres.errCode === 0) {
					//汇总此案例点赞数量
					const likecount = await db.collection('ksample-like').where({
						sample_id: param
					}).get({
						getCount: true
					})
					//切换用户权限，不然数据写不了
					db.setUser({
						role: ['admin']
					})
					//写入点赞的合计数量
					const updatastatue = await db.collection('kfault-sample-set').doc(param)
						.update({ likes: likecount.count })

					// 返回点赞成功，因为记录已经写入点赞表了。合计和汇总的返回数据无需验证。这个表不是很重要。
					return false
				} else {
					return {
						errCode: 'CANCEL_LIKE_IS_FAIL',
						errMsg: '取消点赞失败'
					}
				}
			}
		} catch (e) {
			return e
		}
	}


}